home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / nss / cryptohi.h < prev    next >
C/C++ Source or Header  |  2006-04-20  |  10KB  |  276 lines
  1. /*
  2.  * crypto.h - public data structures and prototypes for the crypto library
  3.  *
  4.  * ***** BEGIN LICENSE BLOCK *****
  5.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  6.  *
  7.  * The contents of this file are subject to the Mozilla Public License Version
  8.  * 1.1 (the "License"); you may not use this file except in compliance with
  9.  * the License. You may obtain a copy of the License at
  10.  * http://www.mozilla.org/MPL/
  11.  *
  12.  * Software distributed under the License is distributed on an "AS IS" basis,
  13.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  14.  * for the specific language governing rights and limitations under the
  15.  * License.
  16.  *
  17.  * The Original Code is the Netscape security libraries.
  18.  *
  19.  * The Initial Developer of the Original Code is
  20.  * Netscape Communications Corporation.
  21.  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  22.  * the Initial Developer. All Rights Reserved.
  23.  *
  24.  * Contributor(s):
  25.  *   Dr Vipul Gupta <vipul.gupta@sun.com>, Sun Microsystems Laboratories
  26.  *
  27.  * Alternatively, the contents of this file may be used under the terms of
  28.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  29.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30.  * in which case the provisions of the GPL or the LGPL are applicable instead
  31.  * of those above. If you wish to allow use of your version of this file only
  32.  * under the terms of either the GPL or the LGPL, and not to allow others to
  33.  * use your version of this file under the terms of the MPL, indicate your
  34.  * decision by deleting the provisions above and replace them with the notice
  35.  * and other provisions required by the GPL or the LGPL. If you do not delete
  36.  * the provisions above, a recipient may use your version of this file under
  37.  * the terms of any one of the MPL, the GPL or the LGPL.
  38.  *
  39.  * ***** END LICENSE BLOCK ***** */
  40. /* $Id: cryptohi.h,v 1.9 2005/03/08 07:08:48 julien.pierre.bugs%sun.com Exp $ */
  41.  
  42. #ifndef _CRYPTOHI_H_
  43. #define _CRYPTOHI_H_
  44.  
  45. #include "blapit.h"
  46.  
  47. #include "seccomon.h"
  48. #include "secoidt.h"
  49. #include "secdert.h"
  50. #include "cryptoht.h"
  51. #include "keyt.h"
  52. #include "certt.h"
  53.  
  54.  
  55. SEC_BEGIN_PROTOS
  56.  
  57.  
  58. /****************************************/
  59. /*
  60. ** DER encode/decode (EC)DSA signatures
  61. */
  62.  
  63. /* ANSI X9.57 defines DSA signatures as DER encoded data.  Our DSA code (and
  64.  * most of the rest of the world) just generates 40 bytes of raw data.  These
  65.  * functions convert between formats.
  66.  */
  67. extern SECStatus DSAU_EncodeDerSig(SECItem *dest, SECItem *src);
  68. extern SECItem *DSAU_DecodeDerSig(SECItem *item);
  69.  
  70. /*
  71.  * Unlike DSA, raw ECDSA signatures do not have a fixed length.
  72.  * Rather they contain two integers r and s whose length depends
  73.  * on the size of the EC key used for signing.
  74.  *
  75.  * We can reuse the DSAU_EncodeDerSig interface to DER encode
  76.  * raw ECDSA signature keeping in mind that the length of r 
  77.  * is the same as that of s and exactly half of src->len.
  78.  *
  79.  * For decoding, we need to pass the length of the desired
  80.  * raw signature (twice the key size) explicitly.
  81.  */
  82. extern SECStatus DSAU_EncodeDerSigWithLen(SECItem *dest, SECItem *src, 
  83.                       unsigned int len);
  84. extern SECItem *DSAU_DecodeDerSigToLen(SECItem *item, unsigned int len);
  85.  
  86. /****************************************/
  87. /*
  88. ** Signature creation operations
  89. */
  90.  
  91. /*
  92. ** Create a new signature context used for signing a data stream.
  93. **    "alg" the signature algorithm to use (e.g. SEC_OID_RSA_WITH_MD5)
  94. **    "privKey" the private key to use
  95. */
  96. extern SGNContext *SGN_NewContext(SECOidTag alg, SECKEYPrivateKey *privKey);
  97.  
  98. /*
  99. ** Destroy a signature-context object
  100. **    "key" the object
  101. **    "freeit" if PR_TRUE then free the object as well as its sub-objects
  102. */
  103. extern void SGN_DestroyContext(SGNContext *cx, PRBool freeit);
  104.  
  105. /*
  106. ** Reset the signing context "cx" to its initial state, preparing it for
  107. ** another stream of data.
  108. */
  109. extern SECStatus SGN_Begin(SGNContext *cx);
  110.  
  111. /*
  112. ** Update the signing context with more data to sign.
  113. **    "cx" the context
  114. **    "input" the input data to sign
  115. **    "inputLen" the length of the input data
  116. */
  117. extern SECStatus SGN_Update(SGNContext *cx, unsigned char *input,
  118.                unsigned int inputLen);
  119.  
  120. /*
  121. ** Finish the signature process. Use either k0 or k1 to sign the data
  122. ** stream that was input using SGN_Update. The resulting signature is
  123. ** formatted using PKCS#1 and then encrypted using RSA private or public
  124. ** encryption.
  125. **    "cx" the context
  126. **    "result" the final signature data (memory is allocated)
  127. */
  128. extern SECStatus SGN_End(SGNContext *cx, SECItem *result);
  129.  
  130. /*
  131. ** Sign a single block of data using private key encryption and given
  132. ** signature/hash algorithm.
  133. **    "result" the final signature data (memory is allocated)
  134. **    "buf" the input data to sign
  135. **    "len" the amount of data to sign
  136. **    "pk" the private key to encrypt with
  137. **    "algid" the signature/hash algorithm to sign with 
  138. **        (must be compatible with the key type).
  139. */
  140. extern SECStatus SEC_SignData(SECItem *result, unsigned char *buf, int len,
  141.                  SECKEYPrivateKey *pk, SECOidTag algid);
  142.  
  143. /*
  144. ** Sign a pre-digested block of data using private key encryption, encoding
  145. **  The given signature/hash algorithm.
  146. **    "result" the final signature data (memory is allocated)
  147. **    "digest" the digest to sign
  148. **    "pk" the private key to encrypt with
  149. **    "algtag" The algorithm tag to encode (need for RSA only)
  150. */
  151. extern SECStatus SGN_Digest(SECKEYPrivateKey *privKey,
  152.                 SECOidTag algtag, SECItem *result, SECItem *digest);
  153.  
  154. /*
  155. ** DER sign a single block of data using private key encryption and the
  156. ** MD5 hashing algorithm. This routine first computes a digital signature
  157. ** using SEC_SignData, then wraps it with an CERTSignedData and then der
  158. ** encodes the result.
  159. **    "arena" is the memory arena to use to allocate data from
  160. **     "result" the final der encoded data (memory is allocated)
  161. **     "buf" the input data to sign
  162. **     "len" the amount of data to sign
  163. **     "pk" the private key to encrypt with
  164. */
  165. extern SECStatus SEC_DerSignData(PRArenaPool *arena, SECItem *result,
  166.                 unsigned char *buf, int len,
  167.                 SECKEYPrivateKey *pk, SECOidTag algid);
  168.  
  169. /*
  170. ** Destroy a signed-data object.
  171. **    "sd" the object
  172. **    "freeit" if PR_TRUE then free the object as well as its sub-objects
  173. */
  174. extern void SEC_DestroySignedData(CERTSignedData *sd, PRBool freeit);
  175.  
  176. /*
  177. ** Get the hash algorithm tag number for the given type of the key and
  178. ** algorithm tag. Returns SEC_OID_UNKNOWN if key and algorithm
  179. ** are not match.
  180. */
  181. extern SECOidTag SEC_GetSignatureAlgorithmOidTag(KeyType keyType,
  182.                                                  SECOidTag hashAlgTag);
  183.  
  184. /****************************************/
  185. /*
  186. ** Signature verification operations
  187. */
  188.  
  189. /*
  190. ** Create a signature verification context.
  191. **    "key" the public key to verify with
  192. **    "sig" the encrypted signature data if sig is NULL then
  193. **       VFY_EndWithSignature must be called with the correct signature at
  194. **       the end of the processing.
  195. **    "algid" specifies the signing algorithm to use.  This must match
  196. **        the key type.
  197. **    "wincx" void pointer to the window context
  198. */
  199. extern VFYContext *VFY_CreateContext(SECKEYPublicKey *key, SECItem *sig,
  200.                      SECOidTag algid, void *wincx);
  201.  
  202. /*
  203. ** Destroy a verification-context object.
  204. **    "cx" the context to destroy
  205. **    "freeit" if PR_TRUE then free the object as well as its sub-objects
  206. */
  207. extern void VFY_DestroyContext(VFYContext *cx, PRBool freeit);
  208.  
  209. extern SECStatus VFY_Begin(VFYContext *cx);
  210.  
  211. /*
  212. ** Update a verification context with more input data. The input data
  213. ** is fed to a secure hash function (depending on what was in the
  214. ** encrypted signature data).
  215. **    "cx" the context
  216. **    "input" the input data
  217. **    "inputLen" the amount of input data
  218. */
  219. extern SECStatus VFY_Update(VFYContext *cx, unsigned char *input,
  220.                 unsigned int inputLen);
  221.  
  222. /*
  223. ** Finish the verification process. The return value is a status which
  224. ** indicates success or failure. On success, the SECSuccess value is
  225. ** returned. Otherwise, SECFailure is returned and the error code found
  226. ** using PORT_GetError() indicates what failure occurred.
  227. **     "cx" the context
  228. */
  229. extern SECStatus VFY_End(VFYContext *cx);
  230.  
  231. /*
  232. ** Finish the verification process. The return value is a status which
  233. ** indicates success or failure. On success, the SECSuccess value is
  234. ** returned. Otherwise, SECFailure is returned and the error code found
  235. ** using PORT_GetError() indicates what failure occurred. If signature is
  236. ** supplied the verification uses this signature to verify, otherwise the
  237. ** signature passed in VFY_CreateContext() is used. 
  238. ** VFY_EndWithSignature(cx,NULL); is identical to VFY_End(cx);.
  239. **     "cx" the context
  240. **     "sig" the encrypted signature data
  241. */
  242. extern SECStatus VFY_EndWithSignature(VFYContext *cx, SECItem *sig);
  243.  
  244.  
  245. /*
  246. ** Verify the signature on a block of data for which we already have
  247. ** the digest. The signature data is an RSA private key encrypted
  248. ** block of data formatted according to PKCS#1.
  249. **     "dig" the digest
  250. **     "key" the public key to check the signature with
  251. **     "sig" the encrypted signature data
  252. **    "algid" specifies the signing algorithm to use.  This must match
  253. **        the key type.
  254. **/
  255. extern SECStatus VFY_VerifyDigest(SECItem *dig, SECKEYPublicKey *key,
  256.                   SECItem *sig, SECOidTag algid, void *wincx);
  257.  
  258. /*
  259. ** Verify the signature on a block of data. The signature data is an RSA
  260. ** private key encrypted block of data formatted according to PKCS#1.
  261. **     "buf" the input data
  262. **     "len" the length of the input data
  263. **     "key" the public key to check the signature with
  264. **     "sig" the encrypted signature data
  265. **    "algid" specifies the signing algorithm to use.  This must match
  266. **        the key type.
  267. */
  268. extern SECStatus VFY_VerifyData(unsigned char *buf, int len,
  269.                 SECKEYPublicKey *key, SECItem *sig,
  270.                 SECOidTag algid, void *wincx);
  271.  
  272.  
  273. SEC_END_PROTOS
  274.  
  275. #endif /* _CRYPTOHI_H_ */
  276.